home *** CD-ROM | disk | FTP | other *** search
/ System Booster / System Booster.iso / Screenblankers / GBlanker / GSource / Blankers / Demons / blank.c next >
C/C++ Source or Header  |  1996-09-26  |  8KB  |  404 lines
  1. /*
  2. **               Demons Blanker
  3. **
  4. **        Copyright © 1995 by Marzio De Biasi
  5. **
  6. **
  7. **    Source:        blank.c
  8. **    Language:    ANSI C
  9. **    Version:    1.0
  10. **    Description:    a module for GarshneBlanker v38.8 modular screen
  11. **            blanker by Micheal D. Bayne, see Demons.doc for
  12. **            further details.
  13. **    Last update:    24 Jan 95        
  14. **    Author:        De Biasi Marzio
  15. **            Address: via Borgo Simoi, 34
  16. **                 31029 Vittorio Veneto (TV)
  17. **                 Italy
  18. **            E-Mail:  debiasi@dimi.uniud.it
  19. **
  20. **    History:    
  21. **
  22. **    ->
  23. **
  24. */
  25.  
  26. #include "/includes.h"
  27.  
  28. #include <math.h>
  29. #include <time.h>
  30. #include <stdlib.h>
  31. #include <exec/memory.h>
  32.  
  33. #define PREF_SIZE     0
  34. #define PREF_COLORS    2
  35. #define PREF_WIDTH    4
  36. #define PREF_HEIGHT    6
  37. #define MODE        8
  38.  
  39.  
  40. #define NSC    2
  41.  
  42. #define OTHER(s)     ((s + 1) & 1)
  43.  
  44. LONG Hei, Wid;
  45. Triplet *ColorTable[NSC];
  46. ULONG    *ctab;
  47. WORD Cl;
  48.  
  49. WORD    *mem[3];
  50.  
  51.  
  52. struct Screen     *pubDem_sc[NSC];
  53. struct RastPort *pubDem_rp[NSC];
  54.  
  55. LONG    pubDem_siz = 3;
  56. WORD    pubDem_w, pubDem_h;
  57. LONG       pubDem_delay = 5;
  58. WORD    pubDem_uw, pubDem_uh, pubDem_cl;
  59. WORD    pubDem_topx, pubDem_topy;
  60.  
  61.  
  62. #include "Demons_rev.h"
  63. STATIC const UBYTE VersTag[] = VERSTAG;
  64.  
  65.  
  66.  
  67.  
  68. VOID Defaults( PrefObject *Prefs )
  69. {
  70.     Prefs[PREF_SIZE].po_Level = 6;
  71.     Prefs[PREF_COLORS].po_Level = 12;
  72.     Prefs[PREF_WIDTH].po_Level = 40;
  73.     Prefs[PREF_HEIGHT].po_Level = 25;
  74.     Prefs[MODE].po_ModeID = getTopScreenMode();
  75.     Prefs[MODE].po_Depth = 4;
  76. }
  77.  
  78.  
  79.  
  80.  
  81. /* ------------------------------------------------------------------- */
  82. /* ---- DrawCell() --------------------------------------------------- */
  83. /* ------------------------------------------------------------------- */
  84.  
  85. void    DrawCell(struct RastPort *rp, WORD x, WORD y, WORD color) {
  86. /*
  87. **  Draws a <pubDem_siz> x <pubDem_siz> box at (<x>,<y>) using color <color>.
  88. */
  89.  
  90.     WORD    ox, oy, t;
  91.  
  92.     SetAPen(rp, color);
  93.  
  94.     ox = x * pubDem_siz + pubDem_topx;
  95.     oy = y * pubDem_siz + pubDem_topy;
  96.  
  97.     if (pubDem_siz > 1) {
  98.     t = pubDem_siz - 1;
  99.     RectFill(rp, ox, oy, ox + t, oy + t);
  100.     }
  101.     else WritePixel(rp, ox, oy);
  102. }
  103.  
  104.  
  105.  
  106.  
  107. /* ------------------------------------------------------------------- */
  108. /* ---- GetCellStat() ------------------------------------------------ */
  109. /* ------------------------------------------------------------------- */
  110.  
  111. WORD    GetCellStat(struct RastPort *rp, WORD x, WORD y ) {
  112. /*
  113. **  Reads the color of the pixel at (<x>,<y>).
  114. */
  115.     WORD    ox, oy;
  116.     WORD    c;
  117.  
  118.     ox = x * pubDem_siz + pubDem_topx;
  119.     oy = y * pubDem_siz + pubDem_topy;
  120.     c = ReadPixel(rp, ox, oy);
  121.  
  122.     return(c);
  123. }
  124.  
  125.  
  126.  
  127.  
  128. /* ------------------------------------------------------------------- */
  129. /* ---- SetUpField() ------------------------------------------------- */
  130. /* ------------------------------------------------------------------- */
  131.  
  132. LONG    SetUpField(LONG src) {
  133. /*
  134. **  Clears screen, then sets each cell to a random color.
  135. */
  136.  
  137.     WORD    i, c;
  138.     WORD    x, y;
  139.     LONG    RetV = OK;
  140.  
  141.     for (i = 0; i < NSC; i++) SetRast( pubDem_rp[i], 0L );
  142.  
  143.     ScreenToFront(pubDem_sc[OTHER(src)]);
  144.  
  145.     for (x = 0; x < pubDem_w; x++) {
  146.     for (y = 0; y < pubDem_h; y++) {
  147.     
  148.         c = lrand48() % pubDem_cl;
  149.         DrawCell(pubDem_rp[src], x, y, c);
  150.     }
  151.     
  152.         if ((RetV = ContinueBlanking()) != OK) goto l_skip_it;
  153.     }
  154.  
  155.     ScreenToFront(pubDem_sc[src]);
  156.  
  157. l_skip_it:
  158.     return(RetV);
  159. }
  160.  
  161.  
  162.  
  163.  
  164. /* ------------------------------------------------------------------- */
  165. /* ---- RedrawCells -------------------------------------------------- */
  166. /* ------------------------------------------------------------------- */
  167.  
  168. LONG    RedrawCells(LONG src, LONG dest) {
  169. /*
  170. **  Checks the neighbours of each cell, then changes its state. 
  171. */
  172.  
  173.     WORD    x, y, xx;
  174.     WORD    i, act, bot, l1, l2, l3;
  175.     WORD    c, cpp, nc, tx;
  176.     UBYTE    no_ch = FALSE;
  177.     LONG    RetV = OK;
  178.     struct BitMap *bm;
  179.  
  180.     for (i = 0; i < (bm = (pubDem_rp[src]->BitMap))->Depth; i++) {
  181.  
  182.     CopyMem(bm->Planes[i],(pubDem_rp[dest]->BitMap)->Planes[i], \
  183.         bm->BytesPerRow * bm->Rows);
  184.     }
  185.  
  186.    
  187.  
  188.     for (xx = 0; xx < pubDem_w; xx++) {
  189.         mem[0][xx] = GetCellStat(pubDem_rp[src], xx, pubDem_h - 1);
  190.         mem[1][xx] = GetCellStat(pubDem_rp[src], xx, 0); 
  191.     }
  192.  
  193.         act = 1;
  194.  
  195.         for (y = 0; y < pubDem_h; y++) {
  196.  
  197.         l1 = (act + 2) % 3;
  198.         l2 = act % 3;
  199.         l3 = (act + 1) % 3;
  200.  
  201.         bot = (y + 1) % pubDem_h;
  202.  
  203.         for (xx = 0; xx < pubDem_w; xx++) {
  204.             mem[l3][xx] = GetCellStat(pubDem_rp[src], xx, bot);
  205.  
  206.         }
  207.  
  208.  
  209.         for (x = 0; x < pubDem_w; x++) {
  210.  
  211.  
  212.         c = mem[l2][x];
  213.         cpp = (c + 1) % pubDem_cl;
  214.         nc = c;
  215.  
  216. /*
  217.         tx = (x > 0)? (x - 1) : (pubDem_w - 1);
  218.  
  219.         if ((mem[l1][tx] == cpp) || (mem[l2][tx] == cpp) || (mem[l3][tx] == cpp)) {
  220.  
  221.             nc = cpp;
  222.             goto l_draw_it;
  223.         }
  224.  
  225.         tx = (x + 1) % pubDem_w;
  226.  
  227.         if ((mem[l1][tx] == cpp) || (mem[l2][tx] == cpp) || (mem[l3][tx] == cpp)) {
  228.             nc = cpp;
  229.             goto l_draw_it;
  230.         }
  231.  
  232.         if ((mem[l1][x] == cpp) || (mem[l3][x] == cpp)) nc = cpp;
  233.  
  234. */
  235.  
  236.         if (mem[l2][((x > 0)? (x - 1) : (pubDem_w - 1))] == cpp) {
  237.  
  238.             nc = cpp;
  239.             goto l_draw_it;
  240.         }
  241.  
  242.         if (mem[l2][((x + 1) % pubDem_w)] == cpp) {
  243.             nc = cpp;
  244.             goto l_draw_it;
  245.         }
  246.  
  247.         if ((mem[l1][x] == cpp) || (mem[l3][x] == cpp)) nc = cpp;
  248.  
  249.  
  250.  
  251. l_draw_it:
  252.         if (nc == cpp) {
  253.             no_ch = TRUE;
  254.             DrawCell(pubDem_rp[dest], x, y, nc);         
  255.         }
  256.  
  257.         if ((RetV = ContinueBlanking()) != OK) goto l_skip_blank;
  258.  
  259.         }
  260.  
  261.  
  262.         act++;
  263.  
  264.         }
  265.     
  266.     ScreenToFront(pubDem_sc[dest]);
  267.  
  268.     if (!no_ch) RetV = SetUpField(dest);
  269.  
  270.  
  271. l_skip_blank:
  272.  
  273.  
  274.     return(RetV);
  275. }
  276.  
  277.  
  278.  
  279.  
  280. /* ------------------------------------------------------------------- */
  281. /* ---- DemonDriver() -------------------------------------------------- */
  282. /* ------------------------------------------------------------------- */
  283.  
  284. LONG    DemonDriver( void ) {
  285. /*
  286. **  Main loop: calls RedrawCells the swaps screens.
  287. */
  288.  
  289.     LONG    RetVal = OK;
  290.     WORD    i;
  291.     LONG    this_screen = 0;
  292.  
  293.  
  294.     pubDem_w = Wid / pubDem_siz;
  295.     pubDem_h = Hei / pubDem_siz; 
  296.  
  297.     if (pubDem_uw < pubDem_w) pubDem_w = pubDem_uw;
  298.     if (pubDem_uh < pubDem_h) pubDem_h = pubDem_uh;
  299.  
  300.     pubDem_topx = (Wid - pubDem_w * pubDem_siz) / 2;
  301.     pubDem_topy = (Hei - pubDem_h * pubDem_siz) / 2;
  302.  
  303.  
  304.     for (i = 0; i < 3; i++) {
  305.     if ((mem[i] = (WORD *)AllocMem(pubDem_w * sizeof(WORD), MEMF_FAST)) == NULL) break;
  306.     }
  307.  
  308.     if (i == 3) {
  309.  
  310.     RetVal = SetUpField(this_screen & 1);
  311.  
  312.         while (RetVal == OK) {
  313.         RetVal = RedrawCells(this_screen & 1, (this_screen + 1) & 1);
  314.     this_screen++;
  315.     }
  316.     }
  317.     else {
  318.     while((RetVal == ContinueBlanking()) == OK) WaitTOF();
  319.     }
  320.  
  321.     for (i = 0; i < 3; i++) {
  322.     if (mem[i]) FreeMem(mem[i], pubDem_w * sizeof(WORD) );
  323.     }
  324.  
  325.     return(RetVal);
  326. }
  327.  
  328.  
  329.  
  330.  
  331. /* ------------------------------------------------------------------- */
  332. /* ---- Blank() ------------------------------------------------------ */
  333. /* ------------------------------------------------------------------- */
  334.  
  335. LONG Blank( PrefObject *Prefs )
  336. {
  337. /*
  338. **  Opens screen, initializes color table, preference values and random
  339. **  numbers generator seed, then call <DemonDriver()>.
  340. */
  341.     struct Window *Wnd[NSC];
  342.     LONG  RetVal;
  343.     WORD    i, j;
  344.  
  345.     srand48(time(0L));
  346.  
  347.     if (Prefs[MODE].po_Depth == 1) Prefs[MODE].po_Depth = 2;
  348.  
  349.     for (i = 0; i < NSC; i++) {
  350.        pubDem_sc[i] = OpenScreenTags( NULL, SA_Depth, Prefs[MODE].po_Depth, SA_Quiet, TRUE,
  351.                          SA_DisplayID, Prefs[MODE].po_ModeID, SA_Behind, TRUE,
  352.                          SA_Overscan, OSCAN_STANDARD, TAG_DONE );
  353.        if (pubDem_sc[i] == NULL) break;
  354.     } 
  355.  
  356.     if( i == NSC )
  357.     {
  358.         Cl = 1L << Prefs[MODE].po_Depth;
  359.  
  360.         Wid = pubDem_sc[0]->Width;
  361.         Hei = pubDem_sc[0]->Height;
  362.  
  363.         for (j = 0; j < NSC; j++) {
  364.             pubDem_rp[j] = &(pubDem_sc[j]->RastPort);
  365.             Wnd[j] = BlankMousePointer( pubDem_sc[j] );
  366.         }
  367.  
  368.            ColorTable[0] = RainbowPalette( pubDem_sc[0], 0L, 1L, 0L );
  369.         ctab = GetColorTable(pubDem_sc[0]);
  370.  
  371.         for (j = 1; j < NSC; j++) {
  372.         
  373.             if ( ctab != NULL) {
  374.             LoadRGB32(&(pubDem_sc[j]->ViewPort), ctab );
  375.             } 
  376.             else {
  377.             LoadRGB4(&(pubDem_sc[j]->ViewPort),(pubDem_sc[j]->ViewPort.ColorMap)->ColorTable, Cl);
  378.             }
  379.         }
  380.  
  381.         pubDem_siz = Prefs[PREF_SIZE].po_Level;
  382.         pubDem_cl = Prefs[PREF_COLORS].po_Level;
  383.         pubDem_uw = Prefs[PREF_WIDTH].po_Level;
  384.         pubDem_uh = Prefs[PREF_HEIGHT].po_Level;
  385.  
  386.         if (pubDem_cl > Cl) pubDem_cl = Cl;
  387.  
  388.         RetVal = DemonDriver();
  389.  
  390.         for (j = 0; j < NSC; j++) {
  391.             UnblankMousePointer( Wnd[j] );
  392.         }
  393.  
  394.         RainbowPalette( 0L, ColorTable[0], 1L, 0L );
  395.  
  396.  
  397.     }
  398.     else RetVal = FAILED;
  399.  
  400.     for (i = 0; i < NSC; i++) if (pubDem_sc[i]) CloseScreen(pubDem_sc[i]);
  401.     
  402.     return(RetVal);
  403. }
  404.